﻿// ***********************************************************************
// Assembly         : Delta_webrender
// Author           : Juan Alberto Cerino Gomez
// Created          : 04-12-2013
//
// Last Modified By : Juan Alberto Cerino Gomez
// Last Modified On : 05-28-2013
// ***********************************************************************
// <copyright file="FormatoGrid.cs" company="Delta Bussines">
//     Copyright (c) 2013  Delta Bussines. All rights reserved.
// </copyright>
// <summary></summary>
// ***********************************************************************
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Web.UI.WebControls;
using Delta_util.Estaticos;
using Delta_entidad.Atributos;
using Delta_util.Clases;
using Delta_entidad.EntidadesControl;
using System.Collections;

namespace Delta_webrender
{
    /// <summary>
    /// Clase encargada de aplicar el formato al GridView, esta clase lee la configuración, ya sea de la entidad u OnLine, y de acuerdo a esta configuración
    /// se presentan los datos al usuario.    
    /// </summary>
    public class FormatoGrid
    {

        /// <summary>
        /// Lista de la configuración de los campos a dibujar
        /// </summary>
        protected List<Cat_campo_tecnico> camposDibujar = new List<Cat_campo_tecnico>();
        /// <summary>
        /// Configuración dinamica OnLine aplicada al tipo de dato.
        /// </summary>
        private List<Cat_campo_tecnico> _configUsers = null;

        /// <summary>
        /// Obtiene la lista de campos a dibujar, aplicando los filtros necesarios a la lista de campos.
        /// </summary>        
        public List<Cat_campo_tecnico> CamposDibujar { get { return camposDibujar; } }

        /// <summary>
        /// Metodo que se encarga de unir la confiuración señalada en la entidad, usando los atributos, y las configuradas OnLine.
        /// Recuerde que cuando un campo cuenta con las dos configuraciones se toma la configuracion OnLine.
        /// </summary>
        /// <param name="tipo">El tipo de dato a configurar.</param>
        /// <param name="def_campos_users">Lista de configuración dinamica.</param>
        public void UnirCampos(Type tipo, List<Cat_campo_tecnico> def_campos_users = null)
        {
            camposDibujar.Clear();
            if (def_campos_users != null)
                _configUsers = def_campos_users;

            foreach (System.Reflection.PropertyInfo propiedad in tipo.GetProperties())
            {
                if (_configUsers == null || !Comun.PropiedadDinamica(propiedad.Name, _configUsers.ToList<dynamic>()))
                {

                    AttPropiedad atributo = Comun.ObtenerAtributoEntidad<AttPropiedad>(tipo, propiedad);
                    AttColumna atributoColumna = Comun.ObtenerAtributoEntidad<AttColumna>(tipo, propiedad);
                    AttEditor atributoEditor = Comun.ObtenerAtributoEntidad<AttEditor>(tipo, propiedad);
                    AttTipo atributoTipo = Comun.ObtenerAtributoEntidad<AttTipo>(tipo, propiedad);

                    if (atributo != null)
                    {
                        Cat_campo_tecnico ncampo = atributo.datos_campo;
                        ncampo.nombre = propiedad.Name;
                        if (atributoEditor != null)
                        {
                            if (ncampo.tipo_editor == null)
                                ncampo.tipo_editor = new Cat_editor();
                            Comun.RellenarEntidadSinNULL(atributoEditor.editor, ncampo.tipo_editor);
                        }

                        if (atributoColumna != null)
                            ncampo.columna_doc = atributoColumna.columna;
                        if (atributoTipo != null)
                            Comun.RellenarEntidadSinNULL(atributoTipo.tipo, ncampo.tipo);

                        camposDibujar.Add(atributo.datos_campo);
                    }
                }
            }

            if (_configUsers != null)
            {
                foreach (dynamic datosUser in _configUsers)
                {

                    if (datosUser.mostrar_tabla)
                        camposDibujar.Insert(0, datosUser);
                }
            }
        }

        /// <summary>
        /// Metodo que se encarga de aplciar el formato grid a un componente GridView.
        /// </summary>
        /// <param name="Pagina">La pagina donde se encuentra el GridView.</param>
        /// <param name="tipo">El tipo de dato a representar en el GridView.</param>
        /// <param name="tipobase">El tipo base a representar en el GridView, este tipo cambia cuando el tipo es general.</param>
        /// <param name="grid">Componente GridView en el cual aplicará la configuración.</param>
        /// <param name="keys">Nombres de los campos que funcionarán como llaves en el GridView.</param>
        /// <param name="configUsers">Configuración dinamica aplicada al tipo.</param>
        /// <param name="permiso_editar">Indica si el componente GridView muestra el botón Editar.</param>
        /// <param name="permite_eliminar">Indica si el componente GridView muestra el botón Eliminar.</param>
        /// <param name="permiso_seleccionar">Indica si el componente GridView muestra el botón Seleccionar.</param>
        /// <param name="operaciones">Lista de operaciónes permitidas en el Delta Grid, de esta lista dependen los 3 parametros anteriores.</param>
        public void AplicarFormatoGrid(dynamic Pagina, Type tipo,
            Type tipobase,
            GridView grid,
            string keys,
            Cat_tipo_gral configUsers = null, bool? permiso_editar = null, bool? permite_eliminar = null, bool? permiso_seleccionar = null,
            params Enumerados.TIPO_OPERACION_GRID[] operaciones)
        {

            grid.Columns.Clear();
            grid.AutoGenerateColumns = false;
            int regPagina = 0;
            AttEntidad dEntidad = Comun.ObtenerAtributoEntidad<AttEntidad>(tipobase);

            if (configUsers != null && configUsers.configuracion_web)
            {
                regPagina = configUsers.registros_por_pag;
                if (tipobase != typeof(ItemGral) && !string.IsNullOrWhiteSpace(configUsers.llaves_tabla))
                    keys = configUsers.llaves_tabla;
                List<Enumerados.TIPO_OPERACION_GRID> atributosWeb = new List<Enumerados.TIPO_OPERACION_GRID>();
                foreach (Operaciones_tipo op in configUsers.operaciones)
                    atributosWeb.Add((Enumerados.TIPO_OPERACION_GRID)op.id_operacion);
                operaciones = atributosWeb.ToArray();
            }
            else
            {
                regPagina = dEntidad.registros;
                operaciones = dEntidad.operaciones;
            }
            if (regPagina > 0)
            {
                grid.PageSize = regPagina;
                grid.PagerSettings.Position = PagerPosition.TopAndBottom;
                grid.AllowPaging = true;
            }

            if (!string.IsNullOrEmpty(keys))
                grid.DataKeyNames = keys.Split(',');
            if (operaciones.Length > 0)
                if (operaciones.Length > 0)
                {
                    CommandField columnaOp = new CommandField();
                    columnaOp.ButtonType = ButtonType.Image;
                    columnaOp.ShowEditButton = operaciones.Contains(Enumerados.TIPO_OPERACION_GRID.ACTUALIZAR) && (permiso_editar.HasValue ? permiso_editar.Value : true);//Utilerias.ObtenerValorBool(permiso_editar);
                    columnaOp.ShowCancelButton = columnaOp.ShowEditButton;
                    columnaOp.ShowDeleteButton = operaciones.Contains(Enumerados.TIPO_OPERACION_GRID.ELIMINAR) && (permite_eliminar.HasValue ? permite_eliminar.Value : true);//Utilerias.ObtenerValorBool(permite_eliminar);
                    columnaOp.ShowSelectButton = operaciones.Contains(Enumerados.TIPO_OPERACION_GRID.SELECCIONAR) && (permiso_seleccionar.HasValue ? permiso_seleccionar.Value : true);//Utilerias.ObtenerValorBool(permiso_seleccionar);

                    columnaOp.DeleteImageUrl = Pagina.ClientScript.GetWebResourceUrl(tipo, "Delta_webControl.imagenes.eliminar.png"); //  "~/imagenes/eliminar.png";
                    columnaOp.SelectImageUrl = Pagina.ClientScript.GetWebResourceUrl(tipo, "Delta_webControl.imagenes.seleccionar.png"); //"~/imagenes/seleccionar.png";
                    columnaOp.EditImageUrl = Pagina.ClientScript.GetWebResourceUrl(tipo, "Delta_webControl.imagenes.editar.png"); //  "~/imagenes/eliminar.png";

                    if (columnaOp.ShowEditButton)
                    {
                        columnaOp.ShowCancelButton = true;
                        columnaOp.CancelImageUrl = Pagina.ClientScript.GetWebResourceUrl(tipo, "Delta_webControl.imagenes.cancel_edicion.png"); //"~/imagenes/cancel_edicion.png";
                        columnaOp.UpdateImageUrl = Pagina.ClientScript.GetWebResourceUrl(tipo, "Delta_webControl.imagenes.guardar.png"); //"~/imagenes/guardar.png";

                    }
                    columnaOp.ItemStyle.Wrap = false;                    
                    grid.Columns.Add(columnaOp);
                }
            if (configUsers != null)
                _configUsers = configUsers.campos;
            UnirCampos(tipobase);
            var consultaCampos = from cp in camposDibujar orderby cp.orden ascending select cp;
            foreach (Cat_campo_tecnico datosUser in consultaCampos)
            {
                if (datosUser.mostrar_tabla)
                {

                    dynamic columnanew = null;


                    if (string.IsNullOrWhiteSpace(datosUser.tipo_editor.grid_editor))
                        columnanew = new BoundField();
                    else
                    {
                        if (string.IsNullOrWhiteSpace(datosUser.tipo_editor.grid_ensamblado))
                            datosUser.tipo_editor.grid_ensamblado = typeof(BoundField).Assembly.FullName;
                        columnanew = Comun.ObtenerTipo(datosUser.tipo_editor.grid_ensamblado, datosUser.tipo_editor.grid_editor);
                    }
                    string formato = datosUser.tipo_editor.grid_formato;

                    if (formato != null)
                    {
                        string[] valores = formato.Split('~');
                        string[] infoEstilo = valores[0].Split('|');
                        if (infoEstilo != null && infoEstilo.Length >= 1)
                            Comun.FijarValorObjeto(columnanew, infoEstilo[infoEstilo.Length - 1], infoEstilo.Length > 1 ? infoEstilo[0] : "DataFormatString");
                    }
                    Comun.FijarValorObjeto(columnanew, true, "HtmlEncode");
                    columnanew.HeaderText = datosUser.titulo;
                    Comun.FijarValorObjeto(columnanew, datosUser.solo_lectura, "ReadOnly");
                    Comun.FijarValorObjeto(columnanew, datosUser.nombre, "DataField");
                    grid.Columns.Add(columnanew);


                }
            }


        }
    }
}
